Shader "Lch/LitMOES Role Hair"
{
    Properties
    {
        [MainTexture] _BaseMap("漫射贴图(_BaseMap)", 2D) = "white" {}

 
        [Toggle]_Com01Enable("换装01[TYPE_COMM]",float) = 0
        [MainTexture] _Com01Map("透贴01(_Com01Map)[TYPE_COMM&_Com01Enable=1]", 2D) = "white" {}
        [HDR]_Com01Color("染色01[TYPE_COMM&_Com01Enable=1]",Color) = (1,1,1,1)
        [Toggle]_Com02Enable("换装02[TYPE_COMM]",float) = 0
        [MainTexture] _Com02Map("透贴02(_Com01Map)[TYPE_COMM&_Com02Enable=1]", 2D) = "white" {}
        [HDR]_Com02Color("染色02[TYPE_COMM&_Com02Enable=1]",Color) = (1,1,1,1)

        [Toggle]_NewType("新模式",float) = 0
        [MainColor] [HDR]_BaseColor("颜色(_BaseColor)", Color) = (1,1,1,1)
        [HDR]_BaseColor1("颜色下(_BaseColor1)", Color) = (1,0,0,1)

        [HDR]_BaseColor2("颜色(_BaseColor2)", Color) = (1,0,1,1)
        [HDR]_BaseColor3("颜色下(_BaseColor3)", Color) = (0,1,0,1)

        [HDR]_BaseColor4("颜色(_BaseColor4)", Color) = (0,1,1,1)
        [HDR]_BaseColor5("颜色下(_BaseColor5)", Color) = (0,0,1,1)


        [NoScaleOffset]_BumpScale("法线强度（_BumpScale）", Range(0,4)) = 1.0
        _BumpMap("法线(_BumpMap)", 2D) = "bump" {}

        [NoScaleOffset]_MetallicGlossMap("通道图(_MetallicGlossMap)", 2D) = "white" {}
        _Metallic("金属度（Metallic）", Range(0.0, 1.0)) = 0.0
        _OcclusionStrength("ao强度（_OcclusionStrength）", Range(0.0, 1.0)) = 1.0

   
        [HDR]_EmissionColor("自发光颜色（_EmissionColor）", Color) = (0,0,0,1)
        _Smoothness("粗糙度（Smoothness）", Range(0.0, 1.0)) = 0.5

 
        _BackLight("背光",Range(0,1)) = 0.9
        _SpecularMaxLimit("光照最大限制",Range(1.0,10)) = 3.0
        _PrimaryShift(" 各向异性控制
         各向异性控制", Range(-1,1)) = -1
		_AnisoPower(" 各向异性强度
         各向异性强度", Range(1,255)) = 50
 
		[HDR]_AnisoGlass(" 高光Glass
         高光Glass", Color) = (0.6,0.6,0.6,0.5)
		_FlowMap("方向图", 2D) = "bump" {} 

         [Enum(Btangent, 0, Tangent, 1,FlowMap, 2 )]_AnisoDir("各向异性方向", float) = 0
      
 

 
		 
         _Cutoff("Alpha Cutoff ", Range(0.0, 1.0)) = 0.0

        [LCHEnum(LCHblendlModel)] _bendModel("混合模式", Int) = 0
 
		[Enum(UnityEngine.Rendering.BlendMode)] _SrcBlend("源混合 SrcBlend", Float) = 1
		[Enum(UnityEngine.Rendering.BlendMode)] _DstBlend("目标混合 DstBlend", Float) = 0
		[Enum(Off, 0, On, 1)]_ZWrite("深度写_ZWrite", float) = 1
		[Enum(UnityEngine.Rendering.CullMode)]_Cull("剔除模式", float) = 2
        
		_OffsetFactor("双材质防穿插,越小越前", Float) = 0
    }
    SubShader
    {
        Tags
        {
            "RenderPipeline"="UniversalPipeline"
            "RenderType"="Opaque"
            "Queue"="Geometry"
        }

        Pass
        {

            Name "ForwardLit"
            Tags{"LightMode" = "UniversalForward"}

            Blend[_SrcBlend][_DstBlend]
            ZWrite[_ZWrite]
            Cull[_Cull]


            HLSLPROGRAM
            #define HALF_LAMBERT
            #define NO_FRESNEL_TERM
            // GPU Instancing
            #pragma multi_compile_instancing

 

            #define _LIGHT_LAYERS
            #define   _SHADOWS_SOFT
            #define _MAIN_LIGHT_SHADOWS_CASCADE
            #define    _ADDITIONAL_LIGHTS
            //#define COLOR_MARK
            #pragma multi_compile        TYPE_HAIR
        
            #define _ALPHATEST_ON
            
            #pragma multi_compile   _ FOG_LINEAR   
 
            //_ADDITIONAL_LIGHT_SHADOWS _LIGHT_LAYERS _MAIN_LIGHT_SHADOWS_CASCADE _SHADOWS_SOFT
            #define _NORMALMAP  

            #define MAIN_LIGHT_CALCULATE_SHADOWS
            #ifdef _NORMALMAP
            #define REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR 

            #endif

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Version.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
          

            
            #ifdef TYPE_HAIR
            #define ANISOTROPIC_ON 
            #define NOT_GGX
 
            #endif
            #define CUSTOM_VERTEX_PARAM   float2 uv2  : TEXCOORD11;
            
            
            #include "lch_global_buffer.hlsl"
            #include "LitMEOSRoleInput.hlsl"
            #include "lch_urp_com.hlsl"
            
            #pragma vertex vert
            #pragma fragment frag
          
            
            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
                FillVaryingsData(input, output);
                output.uv = TRANSFORM_TEX(output.uv, _BaseMap);
                output.uv2 = input.staticLightmapUV.xy;
                return output;
            }
           
            half3 CalculateBlinnPhong(Light light, InputData inputData)
            {
                half3 attenuatedLightColor = light.color * (light.distanceAttenuation * light.shadowAttenuation);
                half3 lightColor = LightingLambert(attenuatedLightColor, light.direction, inputData.normalWS);
 
                #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
                    half smoothness = exp2(10 * _SpecularColor.a + 1);
                    lightColor += LightingSpecular(attenuatedLightColor, light.direction, inputData.normalWS, inputData.viewDirectionWS, half4(_SpecularColor.rgb, 1), smoothness);
                #endif

                return lightColor;
            }
             #ifdef _SSS
            half3 LightingSSS(half3 lightColor ,half3 lightDirectionWS,half3 normalWS,half3 sssColor )
            {
 
                half NdotL =  dot(normalWS, lightDirectionWS) ;
    
                float3 sss  = 0.2*exp(-3.*abs(NdotL)/(sssColor+0.001));
   
                return sssColor *   sss;

            }
            half3 LightingSSS(Light light,half3 normalWS,LchSurfaceData surfaceData)
            {
 
                return LightingSSS(light.color.rgb,light.direction,normalWS ,surfaceData.sssColor.rgb );
 
            }
            #endif
            
            half4 frag(Varyings input,bool isFrontFace : SV_IsFrontFace) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

               
                float2 uv = input.uv;

     

                LchSurfaceData surfaceData;
                InitializeLchSurfaceData(input.uv,input.uv2,input.color, surfaceData);
                 
                 //surfaceData.anisoDirTS = float3(0,1,0);
                BRDFData brdfData;
                InitializeBRDFData(surfaceData , brdfData);

                
        

                half3 normalTS = surfaceData.normalTS;
                
                InputData inputData;
                InitializeInputData(input,  isFrontFace, normalTS, inputData);

                LchAnisoData anisoData;
                
                InitAnisoData(surfaceData,anisoData,inputData);

                half4 shadowMask = CalculateShadowMask(inputData);
    
                AmbientOcclusionFactor aoFactor;
                aoFactor.directAmbientOcclusion = 1.0;
                aoFactor.indirectAmbientOcclusion = surfaceData.occlusion;
 
                Light mainLight = GetMainLight(inputData, shadowMask, aoFactor);
                half3 ambient = inputData.bakedGI.rgb;
 
                MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI);
                float NDotV;
                half3 giColor = LchGlobalIllumination(brdfData, inputData.bakedGI, aoFactor.indirectAmbientOcclusion, inputData.normalWS, inputData.viewDirectionWS,NDotV);
           

                #ifdef _SSS
                giColor *= surfaceData.sssAmb;
                #endif
                uint meshRenderingLayers = GetMeshRenderingLayer();
                half3 color = giColor; 
      
               
               
 
                if (IsMatchingLightLayer(mainLight.layerMask, meshRenderingLayers))
                {

                    
                    if(mainLight.direction.y>0.9999 && LchMainLightParams.w>0.5)
                    {   
                        mainLight.direction = normalize (LchMainLightParams.xyz-inputData.positionWS);
                    }
                    if(surfaceData.backLight>0)
                    {
                        color += LchLightingPhysicallyBasedBackLight(brdfData,anisoData, mainLight.color, mainLight.direction,   mainLight.shadowAttenuation, inputData.normalWS, inputData.viewDirectionWS,surfaceData.backLight );  
                    }
                    else
                    {
                        color += LchLightingPhysicallyBased(brdfData,anisoData, mainLight.color, mainLight.direction,   mainLight.shadowAttenuation, inputData.normalWS, inputData.viewDirectionWS );  
                    }
                    
                    #ifdef _SSS
                    color.rgb += LightingSSS(mainLight,inputData.normalWS,surfaceData);
                    #endif
                      
                }
 
               #if defined(_ADDITIONAL_LIGHTS)
           
              uint pixelLightCount = GetAdditionalLightsCount();

 
              
                #if USE_CLUSTERED_LIGHTING
                for (uint lightIndex = 0; lightIndex < min(_AdditionalLightsDirectionalCount, MAX_VISIBLE_LIGHTS); lightIndex++)
                {
                    Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor);
                    if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
                    {
                    
                        color += LchLightingPhysicallyBased(brdfData,anisoData, light.color, light.direction, light.distanceAttenuation * light.shadowAttenuation, inputData.normalWS, inputData.viewDirectionWS);  
                        
                    }
                    
                }
                #endif
               
                LIGHT_LOOP_BEGIN(pixelLightCount)
                    Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor);
                    if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
                    {
                        color += LchLightingPhysicallyBased(brdfData,anisoData, light.color, light.direction, light.distanceAttenuation * light.shadowAttenuation, inputData.normalWS, inputData.viewDirectionWS);    
                    
                    }
                LIGHT_LOOP_END
                #endif
                #if defined(_ADDITIONAL_LIGHTS_VERTEX)
                lightingData.vertexLightingColor += inputData.vertexLighting * surfaceData.albedo;
                #endif

                color.rgb = min(color.rgb,surfaceData.maxLimit);

                
                color.rgb += surfaceData.emission;

                color.rgb = MixFog(color.rgb, inputData.fogCoord);
               return float4(color,surfaceData.alpha);
            }
            ENDHLSL
        }


        Pass
        {

            Name "ForwardLit"
            Tags{"LightMode" = "Hair"}

            Blend SrcAlpha OneMinusSrcAlpha
            ZWrite Off
            Cull Off


            HLSLPROGRAM
            #define HALF_LAMBERT
            #define NO_FRESNEL_TERM
            // GPU Instancing
            #pragma multi_compile_instancing

 

            #define _LIGHT_LAYERS
            #define   _SHADOWS_SOFT
            #define _MAIN_LIGHT_SHADOWS_CASCADE
            #define    _ADDITIONAL_LIGHTS
            #define COLOR_MARK
            #pragma multi_compile        TYPE_HAIR
        

            
            #pragma multi_compile   _ FOG_LINEAR   
 
            //_ADDITIONAL_LIGHT_SHADOWS _LIGHT_LAYERS _MAIN_LIGHT_SHADOWS_CASCADE _SHADOWS_SOFT
            #define _NORMALMAP  

            #define MAIN_LIGHT_CALCULATE_SHADOWS
            #ifdef _NORMALMAP
            #define REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR 

            #endif

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Version.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
          

            #define CUSTOM_ALPHA_TEST
            
            #ifdef TYPE_HAIR
            #define ANISOTROPIC_ON 
            #define NOT_GGX
 
            #endif
            #define CUSTOM_VERTEX_PARAM   float2 uv2  : TEXCOORD11;
            
            
            #include "lch_global_buffer.hlsl"
            #include "LitMEOSRoleInput.hlsl"
            #include "lch_urp_com.hlsl"
            
            #pragma vertex vert
            #pragma fragment frag
          
            
            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
                FillVaryingsData(input, output);
                output.uv = TRANSFORM_TEX(output.uv, _BaseMap);
                output.uv2 = input.staticLightmapUV.xy;
                return output;
            }
           
            half3 CalculateBlinnPhong(Light light, InputData inputData)
            {
                half3 attenuatedLightColor = light.color * (light.distanceAttenuation * light.shadowAttenuation);
                half3 lightColor = LightingLambert(attenuatedLightColor, light.direction, inputData.normalWS);
 
                #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
                    half smoothness = exp2(10 * _SpecularColor.a + 1);
                    lightColor += LightingSpecular(attenuatedLightColor, light.direction, inputData.normalWS, inputData.viewDirectionWS, half4(_SpecularColor.rgb, 1), smoothness);
                #endif

                return lightColor;
            }
             #ifdef _SSS
            half3 LightingSSS(half3 lightColor ,half3 lightDirectionWS,half3 normalWS,half3 sssColor )
            {
 
                half NdotL =  dot(normalWS, lightDirectionWS) ;
    
                float3 sss  = 0.2*exp(-3.*abs(NdotL)/(sssColor+0.001));
   
                return sssColor *   sss;

            }
            half3 LightingSSS(Light light,half3 normalWS,LchSurfaceData surfaceData)
            {
 
                return LightingSSS(light.color.rgb,light.direction,normalWS ,surfaceData.sssColor.rgb );
 
            }
            #endif
            
            half4 frag(Varyings input,bool isFrontFace : SV_IsFrontFace) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

               
                float2 uv = input.uv;
 
                LchSurfaceData surfaceData;
                InitializeLchSurfaceData(input.uv,input.uv2,input.color, surfaceData);
                 clip(_Cutoff-surfaceData.alpha );

                
                 //
                BRDFData brdfData;
                InitializeBRDFData(surfaceData , brdfData);

                
        

                half3 normalTS = surfaceData.normalTS;
                
                InputData inputData;
                InitializeInputData(input,  isFrontFace, normalTS, inputData);
                

                LchAnisoData anisoData;
                
                InitAnisoData(surfaceData,anisoData,inputData);

                half4 shadowMask = CalculateShadowMask(inputData);
    
                AmbientOcclusionFactor aoFactor;
                aoFactor.directAmbientOcclusion = 1.0;
                aoFactor.indirectAmbientOcclusion = surfaceData.occlusion;
 
                Light mainLight = GetMainLight(inputData, shadowMask, aoFactor);
                half3 ambient = inputData.bakedGI.rgb;
 
                MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI);
                
                float NDotV;
                half3 giColor = LchGlobalIllumination(brdfData, inputData.bakedGI, aoFactor.indirectAmbientOcclusion, inputData.normalWS, inputData.viewDirectionWS,NDotV);
           

                #ifdef _SSS
                giColor *= surfaceData.sssAmb;
                #endif
                uint meshRenderingLayers = GetMeshRenderingLayer();
                half3 color = giColor; 
      
               
               
 
                if (IsMatchingLightLayer(mainLight.layerMask, meshRenderingLayers))
                {

                    
                    if(mainLight.direction.y>0.9999 && LchMainLightParams.w>0.5)
                    {   
                        mainLight.direction = normalize (LchMainLightParams.xyz-inputData.positionWS);
                    }
                    if(surfaceData.backLight>0)
                    {
                        color += LchLightingPhysicallyBasedBackLight(brdfData,anisoData, mainLight.color, mainLight.direction,   mainLight.shadowAttenuation, inputData.normalWS, inputData.viewDirectionWS,surfaceData.backLight );  
                    }
                    else
                    {
                        color += LchLightingPhysicallyBased(brdfData,anisoData, mainLight.color, mainLight.direction,   mainLight.shadowAttenuation, inputData.normalWS, inputData.viewDirectionWS );  
                    }
                    
                    #ifdef _SSS
                    color.rgb += LightingSSS(mainLight,inputData.normalWS,surfaceData);
                    #endif
                      
                }
 
               #if defined(_ADDITIONAL_LIGHTS)
           
              uint pixelLightCount = GetAdditionalLightsCount();

 
              
                #if USE_CLUSTERED_LIGHTING
                for (uint lightIndex = 0; lightIndex < min(_AdditionalLightsDirectionalCount, MAX_VISIBLE_LIGHTS); lightIndex++)
                {
                    Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor);
                    if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
                    {
                    
                        color += LchLightingPhysicallyBased(brdfData,anisoData, light.color, light.direction, light.distanceAttenuation * light.shadowAttenuation, inputData.normalWS, inputData.viewDirectionWS);  
                        
                    }
                    
                }
                #endif
               
                LIGHT_LOOP_BEGIN(pixelLightCount)
                    Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor);
                    if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
                    {
                        color += LchLightingPhysicallyBased(brdfData,anisoData, light.color, light.direction, light.distanceAttenuation * light.shadowAttenuation, inputData.normalWS, inputData.viewDirectionWS);    
                    
                    }
                LIGHT_LOOP_END
                #endif
                #if defined(_ADDITIONAL_LIGHTS_VERTEX)
                lightingData.vertexLightingColor += inputData.vertexLighting * surfaceData.albedo;
                #endif

                color.rgb = min(color.rgb,surfaceData.maxLimit);

                
                color.rgb += surfaceData.emission;

                color.rgb = MixFog(color.rgb, inputData.fogCoord);
               return float4(color,surfaceData.alpha);
            }
            ENDHLSL
        }

        
        Pass
		{
			
			Name "ShadowCaster"
			Tags { "LightMode"="ShadowCaster" }
			ZWrite On
			ZTest LEqual
			AlphaToMask Off
			ColorMask 0
			HLSLPROGRAM
			#define _NORMAL_DROPOFF_TS 1
			#pragma multi_compile_instancing
 
		
			#pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
            //#pragma multi_compile _ DOTS_INSTANCING_ON

			#pragma vertex vert
			#pragma fragment ShadowPassFragmentFun

			#define SHADERPASS SHADERPASS_SHADOWCASTER

			#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
			#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
			#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl"
            #define CBUFFER_ONLY
            #include "LitMEOSRoleInput.hlsl"

			struct VertexInput
			{
				float4 positionOS : POSITION;

                float2 uv                       : TEXCOORD0;
				float3 normalOS : NORMAL;
				
				UNITY_VERTEX_INPUT_INSTANCE_ID
			};

			struct VertexOutput
			{
				  float4 positionCS : SV_POSITION;
                  float2 uv                       : TEXCOORD0;
			 		
				
				UNITY_VERTEX_INPUT_INSTANCE_ID
				UNITY_VERTEX_OUTPUT_STEREO
			};

 
			float3 _LightDirection;
			float3 _LightPosition;

			VertexOutput VertexFunction( VertexInput v )
			{
				VertexOutput o;
				UNITY_SETUP_INSTANCE_ID(v);
				UNITY_TRANSFER_INSTANCE_ID(v, o);
				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO( o );

				float3 positionWS = TransformObjectToWorld( v.positionOS.xyz );
				float3 normalWS = TransformObjectToWorldDir(v.normalOS);
				#if _CASTING_PUNCTUAL_LIGHT_SHADOW
					float3 lightDirectionWS = normalize(_LightPosition - positionWS);
				#else
					float3 lightDirectionWS = _LightDirection;
				#endif

				float4 positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDirectionWS));
				#if UNITY_REVERSED_Z
					positionCS.z = min(positionCS.z, UNITY_NEAR_CLIP_VALUE);
				#else
					positionCS.z = max(positionCS.z, UNITY_NEAR_CLIP_VALUE);
				#endif
				o.positionCS = positionCS;
                o.uv = v.uv;
				return o;
			}

			 
			VertexOutput vert ( VertexInput v )
			{
				return VertexFunction( v );
			}
 

            half4 ShadowPassFragmentFun(VertexOutput input) : SV_TARGET
            {
                Alpha(SampleAlbedoAlpha(input.uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap)).a, _BaseColor, _Cutoff);
                return 0;
            }
			 
			ENDHLSL
		} 

          

        

        Pass
        {
            Name "DepthOnly"
            Tags{"LightMode" = "DepthOnly"}

            ZWrite On
            ColorMask 0
            Cull[_Cull]

            HLSLPROGRAM
   

            #pragma vertex DepthOnlyVertex
            #pragma fragment DepthOnlyFragment

            // -------------------------------------
            // Material Keywords
            #pragma shader_feature_local_fragment _ALPHATEST_ON
           // #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

            //--------------------------------------
            // GPU Instancing
            #pragma multi_compile_instancing
            //#pragma multi_compile _ DOTS_INSTANCING_ON

            
 
             #include "LitMEOSRoleInput.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl"
            ENDHLSL
        }

         
    }
    FallBack "Hidden/Shader Graph/FallbackError"

    CustomEditor "LCHShaderGUIBase" 
}